home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / File / Passwd / Authbasic.php next >
PHP Script  |  2004-10-01  |  11KB  |  387 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PEAR :: File :: Passwd :: Authbasic                                  |
  4. // +----------------------------------------------------------------------+
  5. // | This source file is subject to version 3.0 of the PHP license,       |
  6. // | that is available at http://www.php.net/license/3_0.txt              |
  7. // | If you did not receive a copy of the PHP license and are unable      |
  8. // | to obtain it through the world-wide-web, please send a note to       |
  9. // | license@php.net so we can mail you a copy immediately.               |
  10. // +----------------------------------------------------------------------+
  11. // | Copyright (c) 2003-2004 Michael Wallner <mike@iworks.at>             |
  12. // +----------------------------------------------------------------------+
  13. //
  14. // $Id: Authbasic.php,v 1.15 2004/06/07 19:19:47 mike Exp $
  15.  
  16. /**
  17. * Manipulate AuthUserFiles as used for HTTP Basic Authentication.
  18. *
  19. * @author   Michael Wallner <mike@php.net>
  20. * @package  File_Passwd
  21. */
  22.  
  23. /**
  24. * Requires File::Passwd::Common
  25. */
  26. require_once 'File/Passwd/Common.php';
  27.  
  28. /**
  29. * Manipulate AuthUserFiles as used for HTTP Basic Authentication.
  30. *
  31. * <kbd><u>
  32. *   Usage Example:
  33. * </u></kbd>
  34. * <code>
  35. *   $htp = &File_Passwd::factory('AuthBasic');
  36. *   $htp->setMode('sha');
  37. *   $htp->setFile('/www/mike/auth/.htpasswd');
  38. *   $htp->load();
  39. *   $htp->addUser('mike', 'secret');
  40. *   $htp->save();
  41. * </code>
  42. * 
  43. * <kbd><u>
  44. *   Output of listUser()
  45. * </u></kbd>
  46. * <pre>
  47. *      array
  48. *       + user => crypted_passwd
  49. *       + user => crypted_passwd
  50. * </pre>
  51. * 
  52. * @author   Michael Wallner <mike@php.net>
  53. * @package  File_Passwd
  54. * @version  $Revision: 1.15 $
  55. * @access   public
  56. */
  57. class File_Passwd_Authbasic extends File_Passwd_Common
  58. {
  59.     /** 
  60.     * Path to AuthUserFile
  61.     *
  62.     * @var string
  63.     * @access private
  64.     */
  65.     var $_file = '.htpasswd';
  66.  
  67.     /** 
  68.     * Actual encryption mode
  69.     *
  70.     * @var string
  71.     * @access private
  72.     */
  73.     var $_mode = 'sha';
  74.  
  75.     /** 
  76.     * Supported encryption modes
  77.     *
  78.     * @var array
  79.     * @access private
  80.     */
  81.     var $_modes = array('md5' => 'm', 'des' => 'd', 'sha' => 's');
  82.  
  83.     /** 
  84.     * Constructor
  85.     * 
  86.     * @access public
  87.     * @param  string $file   path to AuthUserFile
  88.     */
  89.     function File_Passwd_Authbasic($file = '.htpasswd')
  90.     {
  91.         File_Passwd_Authbasic::__construct($file);
  92.     }
  93.  
  94.     /**
  95.     * Constructor (ZE2)
  96.     * 
  97.     * Rewritten because DES encryption is not 
  98.     * supportet by the Win32 httpd.
  99.     * 
  100.     * @access protected
  101.     * @param  string $file   path to AuthUserFile
  102.     */
  103.     function __construct($file = '.htpasswd')
  104.     {
  105.         if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
  106.             unset($this->_modes['des']);
  107.         }
  108.         $this->setFile($file);
  109.     }
  110.  
  111.     /**
  112.     * Fast authentication of a certain user
  113.     * 
  114.     * Returns a PEAR_Error if:
  115.     *   o file doesn't exist
  116.     *   o file couldn't be opened in read mode
  117.     *   o file couldn't be locked exclusively
  118.     *   o file couldn't be unlocked (only if auth fails)
  119.     *   o file couldn't be closed (only if auth fails)
  120.     *
  121.     * @static   call this method statically for a reasonable fast authentication
  122.     * 
  123.     * @throws   PEAR_Error
  124.     * @access   public
  125.     * @return   mixed   true if authenticated, false if not or PEAR_Error
  126.     * @param    string  $file   path to passwd file
  127.     * @param    string  $user   user to authenticate
  128.     * @param    string  $pass   plaintext password
  129.     * @param    string  $mode   des, sha or md5
  130.     */
  131.     function staticAuth($file, $user, $pass, $mode)
  132.     {
  133.         $line = File_Passwd_Common::_auth($file, $user);
  134.         if (!$line || PEAR::isError($line)) {
  135.             return $line;
  136.         }
  137.         list(,$real)    = explode(':', $line);
  138.         $crypted        = File_Passwd_Authbasic::_genPass($pass, $real, $mode);
  139.         if (PEAR::isError($crypted)) {
  140.             return $crypted;
  141.         }
  142.         return ($real === $crypted);
  143.     }
  144.     
  145.     /** 
  146.     * Apply changes and rewrite AuthUserFile
  147.     *
  148.     * Returns a PEAR_Error if:
  149.     *   o directory in which the file should reside couldn't be created
  150.     *   o file couldn't be opened in write mode
  151.     *   o file couldn't be locked exclusively
  152.     *   o file couldn't be unlocked
  153.     *   o file couldn't be closed
  154.     * 
  155.     * @throws PEAR_Error
  156.     * @access public
  157.     * @return mixed true on success or PEAR_Error
  158.     */
  159.     function save()
  160.     {
  161.         $content = '';
  162.         foreach ($this->_users as $user => $pass) {
  163.             $content .= $user . ':' . $pass . "\n";
  164.         }
  165.         return $this->_save($content);
  166.     }
  167.  
  168.     /** 
  169.     * Add an user
  170.     *
  171.     * The username must start with an alphabetical character and must NOT
  172.     * contain any other characters than alphanumerics, the underline and dash.
  173.     * 
  174.     * Returns a PEAR_Error if:
  175.     *   o user already exists
  176.     *   o user contains illegal characters
  177.     * 
  178.     * @throws PEAR_Error
  179.     * @access public
  180.     * @return mixed true on success or PEAR_Error
  181.     * @param string $user
  182.     * @param string $pass
  183.     */
  184.     function addUser($user, $pass)
  185.     {
  186.         if ($this->userExists($user)) {
  187.             return PEAR::raiseError(
  188.                 sprintf(FILE_PASSWD_E_EXISTS_ALREADY_STR, 'User ', $user),
  189.                 FILE_PASSWD_E_EXISTS_ALREADY
  190.             );
  191.         }
  192.         if (!preg_match($this->_pcre, $user)) {
  193.             return PEAR::raiseError(
  194.                 sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
  195.                 FILE_PASSWD_E_INVALID_CHARS
  196.             );
  197.         }
  198.         $this->_users[$user] = $this->_genPass($pass);
  199.         return true;
  200.     }
  201.  
  202.     /** 
  203.     * Change the password of a certain user
  204.     *
  205.     * Returns a PEAR_Error if user doesn't exist.
  206.     * 
  207.     * @throws PEAR_Error
  208.     * @access public
  209.     * @return mixed true on success or a PEAR_Error
  210.     * @param string $user   the user whose password should be changed
  211.     * @param string $pass   the new plaintext password
  212.     */
  213.     function changePasswd($user, $pass)
  214.     {
  215.         if (!$this->userExists($user)) {
  216.             return PEAR::raiseError(
  217.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  218.                 FILE_PASSWD_E_EXISTS_NOT
  219.             );
  220.         }
  221.         $this->_users[$user] = $this->_genPass($pass);
  222.         return true;
  223.     }
  224.  
  225.     /** 
  226.     * Verify password
  227.     *
  228.     * Returns a PEAR_Error if:
  229.     *   o user doesn't exist
  230.     *   o an invalid encryption mode was supplied
  231.     * 
  232.     * @throws PEAR_Error
  233.     * @access public
  234.     * @return mixed true if passwords equal, false if they don't, or PEAR_Error
  235.     * @param string $user   the user whose password should be verified
  236.     * @param string $pass   the plaintext password to verify
  237.     */
  238.     function verifyPasswd($user, $pass)
  239.     {
  240.         if (!$this->userExists($user)) {
  241.             return PEAR::raiseError(
  242.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  243.                 FILE_PASSWD_E_EXISTS_NOT
  244.             );
  245.         }
  246.         $real = $this->_users[$user];
  247.         return ($real === $this->_genPass($pass, $real));
  248.     }
  249.  
  250.     /** 
  251.     * Get actual encryption mode
  252.     *
  253.     * @access public
  254.     * @return string
  255.     */
  256.     function getMode()
  257.     {
  258.         return $this->_mode;
  259.     }
  260.  
  261.     /** 
  262.     * Get supported encryption modes
  263.     *
  264.     * <pre>
  265.     *   array
  266.     *    + md5
  267.     *    + sha
  268.     *    + des
  269.     * </pre>
  270.     * 
  271.     * ATTN: DES encryption not available on Win32!
  272.     * 
  273.     * @access public
  274.     * @return array
  275.     */
  276.     function listModes()
  277.     {
  278.         return array_keys($this->_modes);
  279.     }
  280.  
  281.     /** 
  282.     * Set the encryption mode
  283.     *
  284.     * You can choose one of md5, sha or des.
  285.     * 
  286.     * ATTN: DES encryption not available on Win32!
  287.     * 
  288.     * Returns a PEAR_Error if a specific encryption mode is not supported.
  289.     * 
  290.     * @throws PEAR_Error
  291.     * @access public
  292.     * @return mixed true on succes or PEAR_Error
  293.     * @param string $mode
  294.     */
  295.     function setMode($mode)
  296.     {
  297.         $mode = strToLower($mode);
  298.         if (!isset($this->_modes[$mode])) {
  299.             return PEAR::raiseError(
  300.                 sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $this->_mode),
  301.                 FILE_PASSWD_E_INVALID_ENC_MODE
  302.             );
  303.         }
  304.         $this->_mode = $mode;
  305.         return true;
  306.     }
  307.  
  308.     /**
  309.     * Generate password with htpasswd executable
  310.     * 
  311.     * @access   private
  312.     * @return   string  the crypted password
  313.     * @param    string  $pass   the plaintext password
  314.     * @param    string  $salt   the salt to use
  315.     * @param    string  $mode   encyption mode, usually determined from
  316.     *                           <var>$this->_mode</var>
  317.     */
  318.     function _genPass($pass, $salt = null, $mode = null)
  319.     {
  320.         $mode = is_null($mode) ? strToLower($this->_mode) : strToLower($mode);
  321.  
  322.         if ($mode == 'md5') {
  323.             return File_Passwd::crypt_apr_md5($pass, $salt);
  324.         } elseif ($mode == 'des') {
  325.             return File_Passwd::crypt_des($pass, $salt);
  326.         } elseif ($mode == 'sha') {
  327.             return File_Passwd::crypt_sha($pass, $salt);
  328.         }
  329.         
  330.         return PEAR::raiseError(
  331.             sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $mode),
  332.             FILE_PASSWD_E_INVALID_ENC_MODE                
  333.         );
  334.     }
  335.     
  336.     /** 
  337.     * Parse the AuthUserFile
  338.     * 
  339.     * Returns a PEAR_Error if AuthUserFile has invalid format.
  340.     *
  341.     * @throws PEAR_Error
  342.     * @access public
  343.     * @return mixed true on success or PEAR_error
  344.     */
  345.     function parse()
  346.     {
  347.         $this->_users = array();
  348.         foreach ($this->_contents as $line) {
  349.             $user = explode(':', $line);
  350.             if (count($user) != 2) {
  351.                 return PEAR::raiseError(
  352.                     FILE_PASSWD_E_INVALID_FORMAT_STR,
  353.                     FILE_PASSWD_E_INVALID_FORMAT
  354.                 );
  355.             }
  356.             $this->_users[$user[0]] = trim($user[1]);
  357.         }
  358.         $this->_contents = array();
  359.         return true;
  360.     }
  361.     
  362.     /**
  363.     * Generate Password
  364.     * 
  365.     * Returns PEAR_Error FILE_PASSD_E_INVALID_ENC_MODE if the supplied
  366.     * encryption mode is not supported.
  367.     *
  368.     * @static
  369.     * @access   public
  370.     * @return   mixed   The crypted password on success or PEAR_Error on failure.
  371.     * @param    string  $pass The plaintext password.
  372.     * @param    string  $mode The encryption mode to use (des|md5|sha).
  373.     * @param    string  $salt The salt to use.
  374.     */
  375.     function generatePassword($pass, $mode = FILE_PASSWD_DES, $salt = null)
  376.     {
  377.         if (!in_array(strToLower($mode), array('des', 'md5', 'sha'))) {
  378.             return PEAR::raiseError(
  379.                 sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $mode),
  380.                 FILE_PASSWD_E_INVALID_ENC_MODE                
  381.             );
  382.         }
  383.         return File_Passwd_Authbasic::_genPass($pass, $salt, $mode);
  384.     }
  385.     
  386. }
  387. ?>